/*
package com.luoc.base.handler;

import com.alibaba.fastjson.JSON;
import com.tqds.idol.model.Result;
import com.tqds.idol.utils.RedisUtils;
import com.tqds.idol.websocket.channel.GuildChannelRel;
import com.tqds.idol.websocket.entity.ChatMsg;
import com.tqds.idol.websocket.entity.DataContent;
import com.tqds.idol.websocket.enums.MsgActionEnum;
import com.tqds.idol.websocket.service.impl.wsUserServiceImpl;
import com.tqds.idol.websocket.service.wsUserService;
import com.tqds.idol.websocket.utils.JsonUtils;
import com.tqds.idol.websocket.utils.SpringUtil;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.util.concurrent.GlobalEventExecutor;
import lombok.extern.slf4j.Slf4j;


*/
/**
 * @Description: 处理消息的handler
 * TextWebSocketFrame： 在netty中，是用于为websocket专门处理文本的对象，frame是消息的载体
 * <p>
 * 用于记录和管理所有客户端的channle
 * <p>
 * 用@Autowired注入不进来,所以用springUtils直接从ApplicationContenxt中获取
 * <p>
 * 当客户端连接服务端之后（打开连接）
 * 获取客户端的channle，并且放到ChannelGroup中去进行管理
 * <p>
 * 断开时移除用户信息
 * @param ctx
 * @throws Exception
 *//*

@Slf4j
public class ChatHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {

	*/
/**
 * 用于记录和管理所有客户端的channle
 *//*

	public static ChannelGroup users =
			new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

	*/
/**
 * 用@Autowired注入不进来,所以用springUtils直接从ApplicationContenxt中获取
 *//*

	private static wsUserService wsUserService = SpringUtil.getBean(wsUserServiceImpl.class);

	private static RedisUtils redisUtils = SpringUtil.getBean(RedisUtils.class);

	
	@Override
	public void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg)
			throws Exception {
		// 获取客户端传输过来的消息
		String content = msg.text();
		// 获取当前通道 channel 与client 是一对一的
		Channel currentChannel = ctx.channel();
		// 1. 获取客户端发来的消息
		DataContent dataContent = JsonUtils.jsonToPojo(content, DataContent.class);
		Integer action = dataContent.getAction();
		// todo 消息截取空格

		// 初次连接绑定或者重新连接
		if (MsgActionEnum.CONNECT.type.equals(action)) {
			// 2.1  当websocket 第一次open的时候，初始化channel，把用的channel和userid关联起来
			// 绑定用户信息
		   Result result =wsUserService.bindUser(dataContent.getChatMsg(),currentChannel);
		   currentChannel.writeAndFlush(new TextWebSocketFrame(JSON.toJSONString(result)));
        // 公会通知消息
		} else if (MsgActionEnum.CHAT.type.equals(action)) {
			ChatMsg chatMsg = dataContent.getChatMsg();
			String mid = chatMsg.getMid();
		    Result result = wsUserService.say(dataContent.getChatMsg(),currentChannel);
			GuildChannelRel.get(mid).writeAndFlush(new TextWebSocketFrame(JSON.toJSONString(result)));
		// 登陆公会
		} else if (MsgActionEnum.LOGIN.type.equals(action)){
			// 内部已经返回给客户端信息
			wsUserService.login(dataContent.getChatMsg(),currentChannel);
		// 全广播通知
		}else if ( MsgActionEnum.CHATTOALL.type.equals(action)) {
			// 全广播通知
			 Result result =wsUserService.sayWorld(dataContent.getChatMsg(),currentChannel);
			users.writeAndFlush(new TextWebSocketFrame(
					JsonUtils.objectToJson(result)));
		// 偷花记录
		} else  if (MsgActionEnum.STEALFLOWER.type.equals(action)){
			wsUserService.stealflower(dataContent.getChatMsg(),currentChannel);
		// 送花记录
		} else if (MsgActionEnum.SENDFLOWER.type.equals(action)){
			wsUserService.sendFlower(dataContent.getChatMsg(),currentChannel);
		}  else if (MsgActionEnum.JOIN.type.equals(action)){
			wsUserService.join(dataContent.getChatMsg(),currentChannel);
			// 心跳数据
		} else if ( MsgActionEnum.KEEPALIVE.type.equals(action)) {
			//  2.4  心跳类型的消息
			log.info("收到来自channel为[" + currentChannel + "]的心跳包...");
		}
	}
	
	*/
/**
 * 当客户端连接服务端之后（打开连接）
 * 获取客户端的channle，并且放到ChannelGroup中去进行管理
 *//*

	@Override
	public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
		users.add(ctx.channel());
	}

	*/
/**
 *  断开时移除用户信息
 * @param ctx
 * @throws Exception
 *//*

	@Override
	public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
		//在通道关闭时将用户信息从缓存中移除
		redisUtils.del(ctx.channel().id().asLongText());
	    log.info("客户端被移除，channelId为：" + ctx.channel().id().asLongText());
		// 当触发handlerRemoved，ChannelGroup会自动移除对应客户端的channel
		users.remove(ctx.channel());
	}

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
		cause.printStackTrace();
		// 发生异常之后关闭连接（关闭channel），随后从ChannelGroup中移除
		ctx.channel().close();
		users.remove(ctx.channel());
	}

}
*/
